The World of Computer Software/The World of Computer Software.iso/schem-im.zip/SCHEM-IM.TXT

Text File | 1993-01-08 | 38KB | 957 lines

Scheme implementations

Compiled by Jonathan Rees.  Last updated 19 September 1991.
Send corrections to [e-mail].

Send inquiries about the Scheme mailing list ([e-mail] --
it's the same as the comp.lang.scheme newsgroup) to
[e-mail].

The "Revised^3 Report on the Algorithmic Language Scheme" is in
SIGPLAN Notices 21(12), December 1986.  The TeX source for the report
is available by anonymous ftp from altdorf.ai.mit.edu and is included
in the MIT Scheme distribution.  It can also be ordered from:

    Publications Office, Room NE43-818
    MIT Artifical Intelligence Laboratory
    545 Technology Square
    Cambridge MA 02139

Ask for MIT AI Memo 848a, and enclose a check for $6.00 per copy (U.S.
funds) payable to the MIT Artificial Intelligence Laboratory.

Implementations listed here:

    MacScheme
    PC Scheme
    MIT Scheme
    T
    Chez Scheme
    Elk
    Scheme->C
    skim
    SIOD
    Pseudoscheme
    Scheme84
    Vincennes Scheme
    XScheme
    Fools' Lisp
    FDU Scheme
    Gambit
    Pixie Scheme
    scm
    scheme88
    UMB Scheme
    Oaklisp

Implementation:        MacScheme+Toolsmith, MacScheme, Scheme Express,
   MacScheme Student Edition
Implemented by:        Will Clinger, John Ulrich, Liz Heller, and Eric Ost
Supported by:        Lightship Software
   (formerly known as Semantic Microsystems)
Hardware:        Apple Macintosh family (except XL).
            Requires 1024K bytes RAM.
Operating Systems:    Finder/MultiFinder (Macintosh).
Price/Availability:
   MacScheme+Toolsmith: $395, available since December 1986;
   MacScheme: $150, available since August 1985;
   Scheme Express: $69.95, available since February 1989;
   MacScheme Student Edition: available summer 1990, to be
   co-published by The Scientific Press and MIT Press.
Implementation:  MacScheme, MacScheme+Toolsmith: native code
   compiler with compatible byte code interpreter; Scheme Express,
   MacScheme Student Edition: byte code.
Intended Use:
   MacScheme+Toolsmith: professional software development
   MacScheme: personal software development
   Scheme Express: personal computing
   MacScheme Student Edition: education
Contact:        Lightship Software
            P O Box 1636
            Beaverton, OR  97075
            [phone]

These implementations support all essential and most optional features
of the Revised^4 Report on the Algorithmic Language Scheme, and will be
updated to conform to the IEEE standard after it is approved.  MacScheme
and MacScheme+Toolsmith include a fairly decent native code compiler.
Scheme Express and MacScheme Student Edition include only the byte code
compiler/interpreter.  MacScheme Student Edition is limited to
approximately one megabyte of free storage.

Each system includes a simple editor that understands Scheme syntax and
makes good use of multiple windows and the mouse.  Simple graphics are
included also, as are facilities for breaking, tracing, and debugging.
Most run-time errors can be repaired in the debugger.  Pretty-printing
and sorting procedures are provided.

MacScheme+Toolsmith adds very high-level support for interactive menus,
windows, and text editors, high-level support for Macintosh file i/o,
and a comprehensive library of type declarations and Scheme procedures
for calling the low-level Toolbox traps described in Inside Macintosh.
MacScheme also features multi-tasking and a versatile interrupt system
for handling events.  Scheme source code is provided for the standard
interrupt handlers and high-level objects, together with several examples
that show how to program standard features of the Macintosh user interface.

MacScheme+Toolsmith includes the ResEdit graphical resource editor, and
features an Application Builder that creates "double-clickable" heap images
from which unused procedures (the compiler, for example) have been removed
through selective linking.  No royalties are required to distribute these
applications.

[3-1-90]

Implementation:     PC Scheme
Developed by:       Texas Instruments Computer Science Lab
Supported by:       Texas Instruments Digital Systems Group
Hardware:           TI Professional and TI Business-Pro Computers,
                    IBM PC, PC/XT, PC/AT and IBM compatibles
Operating Systems:  MS(tm)-DOS 2.1 (PC-DOS) or better (at least 320K, dual
                        floppy)
Price/Availability: List price - $95
Implementation:     Incrementally compiled to byte-codes
Intended Use:       Education, research, and support of AI software on PCs

PC Scheme is an implementation of Scheme for the TI Professional
Computer and IBM(r) Personal Computer families.  The product
consists of an optimizing compiler, a byte-code interpreter, extensive
run time support, an interactive, display-oriented editor, a language
reference manual, and a user's guide.  The system was developed on the
TI Professional Computer in Scheme itself, with critical run time
routines coded in C and assembly language for increased performance.

PC Scheme provides all the essential and most of the optional features
of the Revised Revised Report on Scheme.  It fully supports the
dialect used in the book "Structure and Interpretation of Computer
Programs" by Abelson and Sussman as well as many extensions developed
at Indiana University, MIT, and TI.  These include first-class engines
and environments and an experimental, object-oriented programming
system with dynamic multiple inheritance called SCOOPS.  Data type
support includes symbols, lists, vectors, strings, fixnums, bignums,
flonums (64 bit IEEE floating point), characters, closures,
continuations, environments, and I/O ports.

Evaluation is based on incremental compilation to byte-coded "virtual
machine" code which is emulated using threaded code techniques.
Informal benchmarks, including some of the Gabriel set, show PC Scheme
programs to be about 3-10 times faster than interpreted IQLISP(tm) and
2-4 times faster than interpreted Golden Common LISP(tm).

To order, write to Texas Instruments, 12501 Research Blvd., MS 2151,
Austin, TX 78759 and ask for TI Part number #2537900-0001.  You may also
order by telephone using MasterCard or VISA by calling 1-(800)-TI-PARTS.

Questions or comments on the product may be directed to the address
given above.  We also welcome less formal technical questions and
comments, which may be directed via CSNET to Oxley@TI-CSL.

[11-12-85]

Implementation:     MIT Scheme

MIT Scheme is a large implementation (the code is over 1 MByte) with
an extensive runtime library, suitable for large projects.  It is used
at MIT both for research and classroom work.

MIT Scheme runs on most Unix machines and on VMS Vaxen; it is fairly
portable but getting it running on other machines or operating systems
requires some work.  The version of MIT Scheme now being distributed
is an interpreter; a native-code compiler and an Emacs-like editor are
in beta-test.  Currently the compiler is ported to the MC680x0 and the
Vax, with an HP Precision Architecture port underway.

For more information about MIT Scheme, or to be added to the MIT
Scheme electronic mailing list, send internet mail to:

    [e-mail]

or US Snail to:

    Scheme Distribution
    c/o Prof. Hal Abelson
    545 Technology Sq. rm 410
    Cambridge MA 02139

To obtain a copy of MIT Scheme:

1) If you have access to the internet, a "tar" file (for Unix) is
available by anonymous ftp (user "anonymous", any password) from
"altdorf.ai.mit.edu"; read the file "README" for instructions.

2) MIT Scheme is also available as part of the GNU Emacs distribution
tape, available for $150 (plus 5% sales tax if in Massachusetts, or
plus $15 for air mail if outside North America) from:

    Free Software Foundation, Inc.
    675 Massachusetts Ave.
    Cambridge MA 02139

3) Otherwise send $200 to the "Scheme Distribution" address above, and
specify what form of tape you want.  We can currently provide:

    * 1600 bpi standard tar tape.
    * 1600 bpi standard VMS backup tape.
    * HP-UX cartridge tar tape.

[1-17-90]

Implementation: T

The T language, developed at Yale University, includes an environment
for Scheme which is at least 99% conformant to the Scheme standard,
and there isn't any performance penalty for using T to run Scheme
since the Scheme environment just allows a different set of names to
be used for the underlying T functions.  T also provides some useful
extensions to Scheme.  T has an optimizing compiler, and best of all
it is available by anonymous ftp from wheaties.ai.mit.edu
(128.52.32.6) in the pub/t3.1 directory.  That directory contains
binaries and sources for T3.1.  Currently available versions are for
Dec3100(pmax), Sun4(sparc),Sun3, Vax/Unix, Encore, Hp workstation,
Apollo and Mac/Aux.  The online version of the T manual is also there
as well as release notes for T3.0 and T3.1.  For Sun and Vax there is
a C/Unix interface to T.

The T compiler is described in a paper by Kranz et al. in the
Proceedings of the 1986 SIGPLAN Compiler Construction Conference.

In the pub/mult directory on wheaties you can get a T dialect extended
for parallelism (uses the future construct) called Mul-T; it runs on
the Encore Multimax.

T is also distributed on the Gnu Emacs tape from the Free Software Foundation.

If you can't get T this way, try to get it from someone who has it, or,
as a last resort, Yale will mail you a tape for $200 (?).

For more information, contact Linda Joyce at Yale ([e-mail],
203-432-4715) or write to

    T Project
    Yale University Dept. of Computer Science
    PO Box 2158
    Yale Station
    New Haven, CT 06520

[1-16-87]

Implementation:     Chez Scheme
Written by:         R. Kent Dybvig, Robert Hieb, and Carl Bruggeman
Supported by:       Cadence Research Systems
Hardware:           VAX (VMS, Ultrix, BSD UNIX), Sun-3 and Sun-4
            (SunOs), MC68000-based Apollo (Domain/IX), various
            Motorola MC88000-based systems, etc.
Implementation:     incrementally compiled to native code
Intended Use:       general (education, research, systems development, etc.)
Price:            ranges from $1500 for one machine to $9,000 for site
                    educational institutions receive 50% discount.

Chez Scheme was first released in early 1985, and is in use at dozens of
sites, mainly in the U.S., Canada, and Europe.  Now in its third major
released version, it supports all of the required features of the R3RS and
nearly all optional features, and will be upgraded to support all of the
features (required and optional) of the forthcoming R4RS and IEEE standard.
It also supports all of the features in The Scheme Programming Language.
The implementation is based on an incremental optimizing compiler with
variable optimization levels.

In addition to the features of the R3RS, Chez Scheme provides:

  * a foreign language interface that allows Scheme programs to
    dynamically load and call C procedures, with automatic conversion
    between Scheme and C data types

  * programmable error and exception handlers

  * multitasking with engines

  * tracing and statistics-gathering facilities

  * a high-level syntax-specification facility (extend-syntax)

  * separate compilation and fast-loading compiled files

  * (inexact) floating point numbers and (exact) arbitrary precision
    integers and ratios

  * support for first-class environments and compatibility with Structure
    and Interpretation of Computer Programs

  * support for complex numbers, ephemeral garbage collection, and new
    machine types (including the DecStation family) will be available
    by July 1990.

Most of our development time has been spent making the implementation as
reliable and as efficient as possible.  In making the system efficient,
we have concentrated on memory and disk utilization and storage management
as well as on compiler speed and speed of generated code.

For information contact Kent Dybvig at:

   Cadence Research Systems
   620 Park Ridge Road
   Bloomington, IN  47408
   812/333-9269
   [e-mail] or [e-mail]

Include your physical mailing address and phone number.

[3-6-90]

Implementation:         Elk
Implemented by:         Oliver Laumann <[e-mail]> <[e-mail]>
Hardware:               VAX, Sun-3, Sun-4, ISI 680x0, Intel 80386, Mips,
                        IBM/RT, and others
Operating Systems:      UNIX/SunOS/Ultrix
Price/Availability:     Free.  Available as source code through the usual
                        sources archives and by e-mail from the author
Intended Use:           Primarily as a general extension language

Elk (Extension Language Kit) is a Scheme interpreter intended to be
used as a general extension language; it is also useful as a stand-alone
implementation of Scheme.

One purpose of the Elk project is to end the recent proliferation of
mutually incompatible Lisp-like extension languages.  Instead of
inventing and implementing yet another extension language, application
programmers can link the Scheme interpreter into their application
in order to make it extensible and highly customizable.

The Elk project was started in 1987 to support ISOTEXT, an ODA-based
document system (a WYSIWYG editor) that is being developed at the
Technical University of Berlin.  Elk has been successfully demonstrated
as the extension language kernel of ISOTEXT, e.g. at the Hanover Fair 1989.

The Elk Scheme interpreter is R^3RS compatible (with some minor exceptions
listed in a separate document); future releases will conform to the R^4RS
and/or P1178 as soon as the respective standards become available.

Non-standard features of the Scheme implementation include:

      o  dynamic loading of object files
      o  creation of an executable image from the running
         interpreter (``unexec'')
      o  a macro facility
      o  environments as first-class objects
      o  dynamic-wind, fluid-let
      o  autoloading, provide/require

The Scheme interpreter can easily be extended by application-specific
new types and primitive procedures.  Such extensions are typically
written in C or C++ and dynamically loaded into the running interpreter.

The current release of Elk includes several such extensions, e.g.
interfaces to the X11 Xlib and to the application programmer interface
of the Xt intrinsics, and interfaces to the Athena, HP, and Motif
widget sets.

[1-17-90]

Scheme->C:  a portable Scheme-to-C compiler

Scheme->C is a Scheme-to-C compiler done at Digital Equipment Corporation's
Western Research Laboratory. The compiler compiles Revised**3 Scheme to C
that is then compiled by the native C compiler for the target machine.
This design results in a portable system that allows either stand-alone
Scheme programs or programs written in both compiled and interpreted
Scheme and other languages.

The Scheme->C system supports the essentials of Revised**3 and most
of the optionals.  Extensions include "expansion passing style"
macros, a foreign function call capability, and interfaces to X11's
Xlib.  The system does provide call-with-current-continuation.
Numbers are represented internally as 29-bit integers, or 64-bit
floating point values, with integer overflow causing automatic conversion.

The compiler is written in Scheme.  Most of the runtime system
(including an interpreter) is written in Scheme.  The generational
compacting garbage collector and a few other things are written in C.
There is a small (< 100 lines) amount of assembly code.  The system
is known to run on VAX's and DECstation 3100's running Ultrix.  Other
ports should be straightforward.

[Sun3, Sun4, and Apollo ports are available.  - editor.]

A research report describing this work can be obtained in either paper or
Postscript forms by sending a message to the WRL document server.  Send a
message to "[e-mail]" with the word "help" in the
subject line to receive detailed instructions.

The system is available for anonymous ftp from 'gatekeeper.dec.com'
[16.1.0.2]. The Scheme->C files are in '/pub/DEC/Scheme-to-C'.  Those
files include:

     README             - overview and copyright notice.
     23feb90.tar.Z      - compressed tar file containing all source
                          and documentation.

Joel Bartlett   [e-mail]

[2-26-90]


Name:     skim (a low fat implementation of Scheme)
Authors: A. Deutsch, R. Dumeur, C. Consel, J.D. Fekete.
Runs-on: Sun[23], Vax, Orion under BSD Unix.
Has:     An interpreter and a compiler (vax only for now).
Features:
    - R3RS compatibility (but misses complex, bignums and ratios);
    - extensible type system and operations;
    - stop/copy gc;
    - scode based interpreter.
Availability:
    - the system has been registered;
    - binaries are available (we do not plan to distribute sources now).
Performance:
    - the interpreter is quite fast (5 times faster that MIT-scheme).
    - the compiler is not an optimizing compiler.
Contact:
    - ...mcvax!inria!litp!{ald|chac|jdf|red}

Organization: L.I.T.P, Universite P7, PARIS

[12-27-87]

Implementation: SIOD (Scheme In One Defun)
Implemented by: George Carrette ([e-mail])
Contact:        [e-mail]
Support:    none
Hardware:    VAX,SUN,ENCORE,AMIGA,MACINTOSH,...
Availability:    anonymous ftp from bu-it.bu.edu src/gjc
                Get either siod-v2.3-shar or siod.*
Dialect:    Sufficient to run some S&ICP examples. Names have been kept
                in line with the most recent standards.
Intended use:   Education. The small size and straightforward implementation
                makes it possible to read and understand in a sitting.
                It can be used as a starting point for shells, command
                interpreters and window hacking interfaces.
Implementation: "C" language with standard-io and the usual math and string
                library calls only. There is a single conditionalized section
                having to do with getting the process cpu runtime. A
                small amount of Scheme code is provided, including some
                macros and a streams implementation.
Remarks:        The synchronous GC, with respect to read/eval/print/gc,
                greatly simplifies the coding. It does however make it
                impractical for lengthy calculations. The SIOD name is
                historical. The following subroutine from the implementation
                should give you an idea of the simplicity.

scan_newspace(newspace)
 struct obj  *newspace;
{register struct obj *ptr;
 for(ptr=newspace; ptr < heap; ++ptr)
   {switch TYPE(ptr)
      {case tc_cons:
       case tc_closure:
     CAR(ptr) = gc_relocate(CAR(ptr));
     CDR(ptr) = gc_relocate(CDR(ptr));
     break;
       case tc_symbol:
     VCELL(ptr) = gc_relocate(VCELL(ptr));
     break;
       default:
     break;}}}

[6-8-88, updated 12-15-89]

Implementation:   Pseudoscheme (Scheme embedded in Common Lisp)
Implemented by:      Jonathan Rees
Support:      Unsupported, although I'll probably continue to improve it.
Hardware, etc.:      Will run in any implementation of Common Lisp.
Availability:      Free.  Distributed as source via anonymous FTP from
          altdorf.ai.mit.edu: archive/pseudo/pseudo-2-7.tar.Z.
Dialect:      Subset.  Tail-recursion is not supported except in the
          special case that a loop is found statically, which is
          when the loop is written explicitly using LETREC or
          something that expands into LETREC (DO, named LET,
          internal DEFINE).  Tail-recursion will of course be
          inherited from the host Common Lisp if it has it.
          All of the essential features of R^3 Scheme exist,
          except for a correct CALL-WITH-CURRENT-CONTINUATION (some
          of you will say that it's not Scheme at all, and I don't
          disagree) and number exactness; most of the non-essential
          features are there too.
Intended use:     Running most Scheme programs using any Common Lisp.
Implementation:   A preprocessor translates Scheme code into Common Lisp
          code, which is then interpreted or compiled by the host
          Common Lisp system.
Remarks:      I did this mostly for my own personal use.  Maybe other
          people will find it useful too.
Contact:      Jonathan Rees ([e-mail]), MIT Artificial
          Intelligence Laboratory, 545 Technology Square, Cambridge
          MA 02139, [phone].

[2-27-86, updated 1-16-90]

Implementation: Scheme84

Scheme84 is a version of Scheme that has been under development at
Indiana University for the past few years, and is used there to support
half a dozen different computer science courses.  The system runs on the
Vax under either VMS or Berkeley Unix.  The developers of Scheme84
intend to supply a compatibility package that will allow the MIT
materials to be run without modification.  The Scheme84 software is in
the public domain, and can be obtained by writing to

    Scheme84 Distribution
    Nancy Garrett
    c/o Dan Friedman
    Department of Computer Science
    Indiana University
    Bloomington, Indiana
    (812)-335-9770
    E-mail address nlg@indiana

The current distribution policy for Scheme84 is that Indiana University
will supply it for free, if you send them a tape and return postage.
(Please specify whether the system is to be for VMS or for Unix.)  On
the other hand, the University reserves the right to begin charging a
fee to recover the cost of distribution, should this become necessary.

[early 1985?]




Implementation: Vincennes Scheme

Vincennes Scheme is a version of Scheme written entirely in portable
C, for Unix V7 and Berkeley 4.1 and 4.2.  It runs on 32-bit machines
(e.g. 68K or Vax) as well as on 16-bit machines (e.g. Z8000 in which
it can fit in 128K).  This Scheme is compatible with the MIT version,
and includes an interpreter with the basic environment: debugger,
history, break, stepper, where. A compiler that generates C code is
available.  For more information, contact

Patrick Greussay
Universite Paris-8-Vincennes
2 rue de la Liberte
Saint-Denis CEDEX 02 93526
France

[early 1985?]


Date:     Fri, 31 Aug 1990 12:55:55 PDT
From: Patrick GREUSSAY <[e-mail]>
To: [e-mail]
Subject: vincennes scheme

The information is still correct.

Implementation: xscheme

See usenet newsgroup  comp.lang.lisp.x  for discussions of xscheme and
xlisp.

MSDOS/XScheme is on uunet.uu.net in the directory
MSDOS/languages/X-scheme.


From: Rusty Haddock <fe2o3![e-mail]>
Subject: XScheme 0.20 for the Amiga available on UUNET

This morning (2/6) I put a Zoo file containing the sources, two
binaries, and documentation for David Betz's XScheme 0.20 (yes, not
even 1.0 yet) with my Amiga/Manx modifications onto UUNET.UU.NET
(192.48.96.2) for anonymous ftp.  The file was

    amiga-sources/xscheme.20.zoo

The two binaries included, xscheme and xscheme.881, were compiled
for using the IEEE math libraries and 68881/2 inline code, respectfully.

Two things to remember:
    1) Use binary mode for ftp'ing.
    2) I simply ftp'ed this onto UUNET's disks without any
       specific permission to do so.  As such, my file may
       disappear without warning.  If this happens I'll find
       another way to keep this ftp'able.

Enjoy!
--
Rusty Haddock        o  {uunet,att,rutgers}!mimsy.umd.edu!fe2o3!rusty

[2-6-90]

From: Jonathan Lee <pasteur!swindle![e-mail]>

Fools' lisp is a Scheme interpreter that follows all the RRRRS
essentials and is reasonably small.  It is written in C and Scheme.
The design allows easy inclusion of new datatypes and primitives.

It is available from scam.berkeley.edu (128.32.138.1) via anonymous
ftp in src/local/fools.tar.Z (a compressed tar file, so remember to
turn on binary mode).

The interpreter runs on the following systems (it will probably run
on any 4.3BSD based UNIX with little trouble):

DECstation 3100 Ultrix 3.1
Sun3 and Sun4 SunOS 4.0.3
VAX Ultrix 3.1 and 4.3BSD
Sequent Symmetry DYNIX(R) V3.0.12
Apollo DN3500 DomainOS Release 10.1 (bsd4.3)

Let me know if you pick up a copy, and feel free to send me any
comments.

Thanks,

Jonathan Lee ([e-mail])

[2-24-90]


Implementation:         FDU Scheme
Written & supported by: Peter Falley
Hardware:               Prime 50-series
Operating System:       Primos
Source languages:       PLP, F77, PMA
Availability:           Beta test version available via
                        anonymous ftp or for a nominal charge (see below).
Intended Use:           Education & research
Implementation:         Primarily an interpreter. A compiler is included,
                        but it has some limitations.
Contact:                Peter Falley
                        Dept. of Math/CS/Physics
                        Fairleigh Dickinson University
                        Madison, NJ 07940
                        [phone]
                        [e-mail]

FDU Scheme has been in use at FDU for several years. It meets all the
requirements of R3RS and also includes almost all of the optional
features. The only serious exception is the format option in
number->string. Support of exact integer and rational arithmetic is
of recent vintage and may still have some bugs. The system is under
continuing development, and support for R4RS and the forthcoming IEEE
standard are planned.

Additional features are:

        * a macro facility.
        * dynamic wind, fluid-let, and engines.
        * a workspace editor. (However, you'll still need
          a good text editor with lisp mode, such as EMACS
          or vi.)
        * programmable error and quit handling.
        * Support for integers up to 8190 decimal digits.
        * Access to operating system facilities from within
          the interpreter.
        * trace and break debugging facilities.
        * A complete manual, including a brief introduction
          to Scheme.

A beta test version of the system may be obtained by anonymous ftp
(username: anonymous; password: anonymous) from fdumda.fdu.edu
(132.238.1.1). Attach to the Scheme subdirectory and transfer all
files in it and its subdirectories using file type binary. Transfer
will be slow, since our network access is at 9600 baud. Alternatively,
send a check for $30 made out to Fairleigh Dickinson University to the
above address, and we'll send you a tape.

[23 Aug 90]

Implementation: Gambit

Version 1.5 of the Gambit Scheme system is now available.  A
couple of minor bugs have been fixed from version 1.4.  The support
for parallelism has been greatly improved.  The compiler now generates
very efficient code for futures.  There is also a new tool, gsx, for
visualizing processor activity on the GP1000 parallel computer.

You can get a copy of Gambit (release 1.5) via anonymous ftp from
the machine acorn.cs.brandeis.edu (address 129.64.3.8).  It is in the
/dist directory and is compressed (about 400K).  Don't forget to set
binary mode when you transfer the system.

For those who don't know about Gambit, here is a repeat of the
previous annoucement:

Gambit is an optimizing Scheme compiler/system under development at
Brandeis university.  It was designed with efficiency and portability
as primary concerns.  The current release has a back end which
generates M68020 code that runs on M680x0 based unix machines (SUN3,
HP300, BBN GP1000, etc).

Gambit supports the IEEE Scheme standard and the `future' construct.
Only exact arithmetic is implemented (bignums and ratnums but no
flonums).  The system contains an interpreter that offers a minimal
debugging environment.

When compiled with Gambit, Gabriel's benchmarks take (on the average)
50% and 70% of the run time required by code compiled with MIT-Scheme
and T3.1, respectively.

Please give me some feedback on the system if you do try it out.

Marc   -- [e-mail]

[30 Dec 90]

Date: 15 Jan 91 17:04:29 GMT
From: "Jay R. Freeman" <argosy![e-mail]>
Subject: Shareware Scheme for Macintosh -- new release
To: [e-mail]

    There is a 5 January 1991 upgrade of "Pixie Scheme", my
shareware Macintosh Scheme interpreter, which is a rather
complete (but slow) implementation of "R3"-dialect Scheme:  Its
main lack is numeric types beyond 32-bit signed integer and 32-
and 80-bit floats.  New this release is on-line help, a wimpy
compiler, miscellaneous enhancements and some bug fixes.

    Pixie Scheme requires a Mac Plus or better, 1 MByte of RAM
and Macintosh system software 6 or newer.

    The distribution includes two program versions (one uses
68020 / 68881 code) and a HyperCard help stack.  It is too big
to EMail -- 600 KBytes compressed, more after (eg) BinHex.

    I gave copies to BMUG and to Boston Computer Society
Macintosh Group at the January 1991 MacWorld Expo.  I mailed
copies (postal service) to everyone I know who has put Pixie
Scheme on a bulletin board or archive.

    Until 1 March 1991, I will mail you Pixie Scheme if you send
me an 800 KByte disc, a mailer and return postage.  (Non-US:
about five international reply coupons.)  If you take this offer
you may ignore my (one-dollar) shareware donation request.

    USE A STOUT MAILER!  Discs rub through plain envelopes in
the mail, and stamp-cancelling machines damage them.

                    Jay Reynolds Freeman
                       P. O. Box 60628
                Palo Alto, CA, 94306-0628, USA

    (I hope this announcement is appropriate use of the net; I do
Pixie Scheme essentially as a public service.)

[15 Jan 91]


This message announces the availablility of a new implementation of
Scheme scm1-1 and of a conformance test file for IEEE Scheme.

Scm conforms to Revised^3.99 Report on the Algorithmic Language Scheme
[Draft August 31, 1989] and the IEEE spec.  Scm runs under Unix, VMS,
and Microsoft C on IBM PCs.  Scm is interpreted and has 30 bit
immediate integers for numbers in version 1-1.  Scm uses and garbage
collects off the C-stack.  This allows routines to be written in C
without regard to GC visibility.  Full call-with-current-continuations
are supported except on VAX and SUN4.  Stack (escape)
call-with-current-continuations are supported on all machines.
Documentation is included on the internal representation and how to
extend or include scm in other programs.

ftp altdorf.ai.mit.edu (anonymous)
cd archive/scm

This directory contains the distribution version 1.1 of scm.
  The file `scm1-1.exe' is an IBM PC executable of scm.
  `scm1-1.shar' is a shar file of the C code distribution.
  `scm1-1.tar.Z' is a compressed tar file of the C code distribution.
  `test.scm' is Scheme code which tests conformity with the IEEE spec.
    It is included in the shar and tar files.  It does not yet test
    the input and output functions.  I will include additions
    that are mailed to me.

To receive an IBM PC floppy disk with the distribution and executable
files send $50 to Aubrey Jaffer, 84 Pleasant St. Wakefield MA 01880, USA.

     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 1, or (at your option)
     any later version.

     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

[1-24-91]

Oaklisp is an object-oriented superset of Scheme.  Scheme is rebuilt
upon an underlying substrate of object-oriented goop with first class
types, making the integration between the Scheme and the
object-oriented componants of the language seamless, and allowing
lexically distributed method definitions, lexical scoping, and other
conveniences lacking in most object-oriented lisp subsystems.  The
implementation, although bytecode-based, is surprisingly zippy,
extremely portable (has been run on most everything), and amenable to
augmentation with native-code compilers.

References:

    "The Implementation of Oaklisp," in "Topics in Advanced
    Language Implementation" edited by Peter Lee, MIT Press, 1990.

    "Oaklisp: an Object-Oriented Dialect of Scheme," Lisp and
    Symbolic Computation v1n1, Klewer Associates, May 1988.

    "Oaklisp: an Object-Oriented Scheme with First Class Types,"
    proceedings of OOPSLA-86 (published as a special issue of
    SIGPLAN Notices.)

    "The Oaklisp Language Manual" and "The Oaklisp Implementation
    Guide," available by FTP.

A compressed tar file of the implementation is available by FTP, as
are the language and implementation manuals:

    % ftp f.gp.cs.cmu.edu (128.2.250.164)
    Connected to f.gp.cs.cmu.edu.
    ftp> user anonymous [e-mail]
    ftp> cd /usr/bap/oak/ftpable
    ftp> binary
    ftp> dir

    -rw-r--r--  1 bap   151636 Nov 15 15:40 manuals.PS.tar.Z
    -rw-r--r--  1 bap    62891 Nov 15 15:40 manuals.dvi.tar.Z
    -rw-r--r--  1 bap    94565 Nov 15 15:40 manuals.src.tar.Z
    -rw-r--r--  1 bap  1911374 Dec 15 16:10 release.tar.Z

    ftp> get release.tar.Z
    ftp> get manuals.PS.tar.Z

[2-19-91]

Date: 19 Mar 90 07:04:53 GMT
From: Dorai Sitaram <datura![e-mail]>
To: [e-mail]
Subject: Re: Where can I Get Scheme-in-LISP?

In article <[e-mail]> [e-mail] (Peter C Olsen) writes:
>
>I'm looking for an implementation of Scheme written in Common Lisp.

how:        anonymous ftp
where:        rice.edu
file:        public/scheme88.sh

[3-19-90]



Date: Thu, 2 Aug 90 09:32:33 -0700
From: [e-mail] (Robert Kelley)
To: [e-mail]
Subject: There's also UMB Scheme
Cc: [e-mail]

by William R. Campbell, et. al.

I found it on ucbarpa.berkeley.edu in pub/UMB_scheme.tar.Z

[8-2-90]



Date: 10 Mar 91 21:39:51 GMT
From: Richard Pattis <[e-mail]>
Organization: U of Washington, Computer Science, Seattle
Subject: New Scheme Book/Implementation
To: [e-mail]

  I met three fascinating gentleman at the ACM's SIGCSE conference.  They all
teach Scheme at the middle- and high-school level. Recently, they have self-
published a book called "The Schemer's Guide"; this book is above the level
of "The Little Lisper" but below that of Springer and Friedman.  Besides
gently introducing the concepts of symbolic manipulation, functional
programming, and recursion, the book includes discussions of currying,
accumulating/mapping/filtering, delayed evaluation, and call/cc.  The book
looks professionally done, and runs over 300 pages and they charge about $30.
The authors are Iain Ferguson, Edward Martin, and Burt Kaufman.

  One of the authors (Iain) has written a Scheme interpreter (in C, called
EdScheme) which is available on IBMs, Ataris, and in September on Macs. Look
for a review of EdScheme in the May 1991 issue of the international edition
of BYTE. It comes with a professionaly typeset 124 page guide and costs about
$50. Both book and software are available on a 60 day money-back offer.

  These guys are truly committed to Scheme; I admire the lengths to which they
have already gone to see their vision of how programming should be taught. I'd
like to see their work become known in a wider context: their contacts in the
Computer Science world (even K-12) are almost NIL.  If you'd like to lend
them some support and help them make contact with other instructors teaching
Scheme, at any level but especially high-school/college, and make them a
little more savy about the wide-world-of-Scheme, please contact

        Schemers Inc.
        4250 Galt Ocean Mile, Suite 7-U
        Ft. Lauderdale, FL.  33308
        [phone]               - this is one of the guy's home phone

Rich Pattis

(sorry this was so gushy, but I was really blown-away by these guys; I have
 no financial interest in their work: they offered my a free copy, but I
 figured they needed a boost, so I bought one).

[3-10-91]

Date: 12 Mar 91 05:29:48 GMT
From: Richard Pattis <[e-mail]>

I just found out that Schemers Inc. has an e-mail address.  Because I've
already received a few requests (and since I want to head off more), here
it is:

   [e-mail]

I think the person receiving mail at this address is Burt Kaufman.


Implementation:         FDU Scheme
Written & supported by: Peter Falley
Hardware:               Prime 50-series
Operating System:       Primos
Source languages:       PLP, F77, PMA
Availability:           Beta test version available via
                        anonymous ftp (see below).
Intended Use:           Education & research
Implementation:         Primarily an interpreter. A compiler is included,
                        but it has limitations.
Contact:                Peter Falley
                        Dept. of Math/CS/Physics
                        Fairleigh Dickinson University
                        Madison, NJ 07940
                        [phone]
                        [e-mail]

FDU Scheme has been in use at FDU for several years. It meets all the
requirements of R3RS and also includes almost all of the optional
features. The only serious exception is the format option in
number->string. Support of exact integer and rational arithmetic is
of recent vintage and may still have some bugs. The system may undergo
further development to support R4RS and/or the new IEEE standard.

Additional features are:

        * a macro facility.
        * dynamic wind, fluid-let, and engines.
        * a workspace editor. (However, you'll still need
          a good text editor with lisp mode, such as EMACS
          or vi.)
        * programmable error and quit handling.
        * Support for integers up to 8190 decimal digits.
        * Access to operating system facilities from within
          the interpreter.
        * trace and break debugging facilities.
        * A complete manual, including a brief introduction
          to Scheme.

A beta test version of the system may be obtained by anonymous ftp
(username: anonymous; password: <RETURN>) from fdumda.fdu.edu
(132.238.1.1). Attach to the Scheme subdirectory (cd '*>scheme')
and transfer all files in it and its subdirectories using file type binary.

[9-18-91]